package com.shuang.graph1;
//
//import java.util.*;
////方法一：邻接矩阵存储
//public class Main {
//
//    //全局变量用于存放单条路径和最后的结果集
//    static List<Integer> path = new ArrayList<>();
//    static List<List<Integer>> result = new ArrayList<>();
//
//    public static void main(String[] args) {
//        //输入第一行 n个节点 m条边
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int m = sc.nextInt();
//
//        //创建邻接矩阵作为图(节点编号从1到n，所以申请 n+1 这么大的数组)
//        int[][] graph = new int[n + 1][n + 1];
//
//        //输入后面m行个数
//        for (int i = 1; i <= m; i++) {
//            int s = sc.nextInt();
//            int t = sc.nextInt();
//
//            //当邻接矩阵中位置值为1时 表示这两个节点相连s->t
//            graph[s][t] = 1;
//        }
//
//        //递归之前先把第一个节点 1 存进去后续递归并没有处理节点1
//        path.add(1);
//        //调用递归实现
//        dfs(graph, 1, n);
//
//        if (result.isEmpty()) {
//            System.out.print(-1);
//        } else {
//            //输出结果 (保证最后一个数字后面不加空格其余的有空格)
//            for (List<Integer> pa : result) {
//                for (int i = 0; i < pa.size() - 1; i++) {
//                    System.out.print(pa.get(i) + " ");
//                }
//                System.out.println(pa.get(pa.size() - 1));
//            }
//        }
//    }
//
//    //将图，遍历到的节点和终止节点传进来
//    public static void dfs(int[][] graph, int x, int n) {
//        //终止条件
//        if (x == n) {
//            result.add(new ArrayList(path));
//            return;
//        }
//
//        //深度优先搜索 遍历节点
//        for (int i = 1; i <= n; i++) {
//            if (graph[x][i] == 1) {
//                //说明找到了与当前节点相连的节点位置
//                //将路径存下来
//                path.add(i);
//                //接着递归到下一个节点
//                dfs(graph, i, n);
//                //回溯
//                path.remove(path.size() - 1);
//            }
//        }
//    }
//}


import java.util.*;
//方法2：邻接表存储
public class Main {
    static List<List<Integer>> result = new ArrayList<>(); // 收集符合条件的路径
    static List<Integer> path = new ArrayList<>(); // 1节点到终点的路径

    public static void dfs(List<LinkedList<Integer>> graph, int x, int n) {
        if (x == n) { // 找到符合条件的一条路径
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i : graph.get(x)) { // 找到 x指向的节点
            path.add(i); // 遍历到的节点加入到路径中来
            dfs(graph, i, n); // 进入下一层递归
            path.remove(path.size() - 1); // 回溯，撤销本节点
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        // 节点编号从1到n，所以申请 n+1 这么大的数组
        List<LinkedList<Integer>> graph = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            graph.add(new LinkedList<>());
        }

        while (m-- > 0) {
            int s = scanner.nextInt();
            int t = scanner.nextInt();
            // 使用邻接表表示 s -> t 是相连的
            graph.get(s).add(t);
        }

        path.add(1); // 无论什么路径已经是从1节点出发
        dfs(graph, 1, n); // 开始遍历

        // 输出结果
        if (result.isEmpty()) System.out.println(-1);
        for (List<Integer> pa : result) {
            for (int i = 0; i < pa.size() - 1; i++) {
                System.out.print(pa.get(i) + " ");
            }
            System.out.println(pa.get(pa.size() - 1));
        }
    }
}